home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1995 August: Tool Chest / Dev.CD Aug 95 TC / Dev.CD Aug 95 TC.toast / Tool Chest / Interfaces / UniversalInterfaces 2.0 / PInterfaces / Resources.p < prev    next >
Encoding:
Text File  |  1995-04-18  |  9.2 KB  |  346 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        Resources.p
  3.  
  4.      Contains:    Resource Manager Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Package:    Universal Interfaces 2.0 in “MPW Latest” on ETO #17
  8.  
  9.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13.                  stack.  Include the file and version information (from above)
  14.                  in the problem description and send to:
  15.                      Internet:    apple.bugs@applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. }
  19.  
  20. {$IFC UNDEFINED UsingIncludes}
  21. {$SETC UsingIncludes := 0}
  22. {$ENDC}
  23.  
  24. {$IFC NOT UsingIncludes}
  25.  UNIT Resources;
  26.  INTERFACE
  27. {$ENDC}
  28.  
  29. {$IFC UNDEFINED __RESOURCES__}
  30. {$SETC __RESOURCES__ := 1}
  31.  
  32. {$I+}
  33. {$SETC ResourcesIncludes := UsingIncludes}
  34. {$SETC UsingIncludes := 1}
  35.  
  36.  
  37. {$IFC UNDEFINED __TYPES__}
  38. {$I Types.p}
  39. {$ENDC}
  40. {    ConditionalMacros.p                                            }
  41.  
  42. {$IFC UNDEFINED __MIXEDMODE__}
  43. {$I MixedMode.p}
  44. {$ENDC}
  45.  
  46. {$IFC UNDEFINED __FILES__}
  47. {$I Files.p}
  48. {$ENDC}
  49. {    OSUtils.p                                                    }
  50. {        Memory.p                                                }
  51.  
  52. {$PUSH}
  53. {$ALIGN MAC68K}
  54. {$LibExport+}
  55.  
  56. CONST
  57.     resSysHeap                    = 64;                            {System or application heap?}
  58.     resPurgeable                = 32;                            {Purgeable resource?}
  59.     resLocked                    = 16;                            {Load it in locked?}
  60.     resProtected                = 8;                            {Protected?}
  61.     resPreload                    = 4;                            {Load in on OpenResFile?}
  62.     resChanged                    = 2;                            {Resource changed?}
  63.     mapReadOnly                    = 128;                            {Resource file read-only}
  64.     mapCompact                    = 64;                            {Compact resource file}
  65.     mapChanged                    = 32;                            {Write map out at update}
  66.     kResFileNotOpened            = -1;                            {ref num return as error when opening a resource file}
  67.     kSystemResFile                = 0;                            {this is the default ref num to the system file}
  68.  
  69. TYPE
  70.     {
  71.         ResErrProcPtr uses register based parameters on the 68k and cannot
  72.         be written in or called from a high-level language without the help of
  73.         mixed mode or assembly glue.
  74.  
  75.         In:
  76.          => thErr           D0.W
  77.     }
  78.     ResErrProcPtr = Register68kProcPtr;  { register PROCEDURE ResErr(thErr: OSErr); }
  79.     ResErrUPP = UniversalProcPtr;
  80.  
  81. CONST
  82.     uppResErrProcInfo = $00001002; { Register PROCEDURE (2 bytes in D0); }
  83.  
  84. FUNCTION NewResErrProc(userRoutine: ResErrProcPtr): ResErrUPP;
  85.     {$IFC NOT GENERATINGCFM }
  86.     INLINE $2E9F;
  87.     {$ENDC}
  88.  
  89. PROCEDURE CallResErrProc(thErr: OSErr; userRoutine: ResErrUPP);
  90.     {$IFC NOT GENERATINGCFM}
  91.     {To be implemented:  Glue to move parameters into registers.}
  92.     {$ENDC}
  93. {    These are no longer needed.
  94.  *    CFM provides us with the necessary run time initialization
  95.  *    entry points.
  96.  }
  97.  
  98. FUNCTION InitResources: INTEGER;
  99.     {$IFC NOT GENERATINGCFM}
  100.     INLINE $A995;
  101.     {$ENDC}
  102. PROCEDURE RsrcZoneInit;
  103.     {$IFC NOT GENERATINGCFM}
  104.     INLINE $A996;
  105.     {$ENDC}
  106. PROCEDURE CloseResFile(refNum: INTEGER);
  107.     {$IFC NOT GENERATINGCFM}
  108.     INLINE $A99A;
  109.     {$ENDC}
  110. FUNCTION ResError: INTEGER;
  111.     {$IFC NOT GENERATINGCFM}
  112.     INLINE $A9AF;
  113.     {$ENDC}
  114. FUNCTION CurResFile: INTEGER;
  115.     {$IFC NOT GENERATINGCFM}
  116.     INLINE $A994;
  117.     {$ENDC}
  118. FUNCTION HomeResFile(theResource: Handle): INTEGER;
  119.     {$IFC NOT GENERATINGCFM}
  120.     INLINE $A9A4;
  121.     {$ENDC}
  122. PROCEDURE CreateResFile(fileName: ConstStr255Param);
  123.     {$IFC NOT GENERATINGCFM}
  124.     INLINE $A9B1;
  125.     {$ENDC}
  126. FUNCTION OpenResFile(fileName: ConstStr255Param): INTEGER;
  127.     {$IFC NOT GENERATINGCFM}
  128.     INLINE $A997;
  129.     {$ENDC}
  130. PROCEDURE UseResFile(refNum: INTEGER);
  131.     {$IFC NOT GENERATINGCFM}
  132.     INLINE $A998;
  133.     {$ENDC}
  134. FUNCTION CountTypes: INTEGER;
  135.     {$IFC NOT GENERATINGCFM}
  136.     INLINE $A99E;
  137.     {$ENDC}
  138. FUNCTION Count1Types: INTEGER;
  139.     {$IFC NOT GENERATINGCFM}
  140.     INLINE $A81C;
  141.     {$ENDC}
  142. PROCEDURE GetIndType(VAR theType: ResType; index: INTEGER);
  143.     {$IFC NOT GENERATINGCFM}
  144.     INLINE $A99F;
  145.     {$ENDC}
  146. PROCEDURE Get1IndType(VAR theType: ResType; index: INTEGER);
  147.     {$IFC NOT GENERATINGCFM}
  148.     INLINE $A80F;
  149.     {$ENDC}
  150. PROCEDURE SetResLoad(load: BOOLEAN);
  151.     {$IFC NOT GENERATINGCFM}
  152.     INLINE $A99B;
  153.     {$ENDC}
  154. FUNCTION CountResources(theType: ResType): INTEGER;
  155.     {$IFC NOT GENERATINGCFM}
  156.     INLINE $A99C;
  157.     {$ENDC}
  158. FUNCTION Count1Resources(theType: ResType): INTEGER;
  159.     {$IFC NOT GENERATINGCFM}
  160.     INLINE $A80D;
  161.     {$ENDC}
  162. FUNCTION GetIndResource(theType: ResType; index: INTEGER): Handle;
  163.     {$IFC NOT GENERATINGCFM}
  164.     INLINE $A99D;
  165.     {$ENDC}
  166. FUNCTION Get1IndResource(theType: ResType; index: INTEGER): Handle;
  167.     {$IFC NOT GENERATINGCFM}
  168.     INLINE $A80E;
  169.     {$ENDC}
  170. FUNCTION GetResource(theType: ResType; theID: INTEGER): Handle;
  171.     {$IFC NOT GENERATINGCFM}
  172.     INLINE $A9A0;
  173.     {$ENDC}
  174. FUNCTION Get1Resource(theType: ResType; theID: INTEGER): Handle;
  175.     {$IFC NOT GENERATINGCFM}
  176.     INLINE $A81F;
  177.     {$ENDC}
  178. FUNCTION GetNamedResource(theType: ResType; name: ConstStr255Param): Handle;
  179.     {$IFC NOT GENERATINGCFM}
  180.     INLINE $A9A1;
  181.     {$ENDC}
  182. FUNCTION Get1NamedResource(theType: ResType; name: ConstStr255Param): Handle;
  183.     {$IFC NOT GENERATINGCFM}
  184.     INLINE $A820;
  185.     {$ENDC}
  186. PROCEDURE LoadResource(theResource: Handle);
  187.     {$IFC NOT GENERATINGCFM}
  188.     INLINE $A9A2;
  189.     {$ENDC}
  190. PROCEDURE ReleaseResource(theResource: Handle);
  191.     {$IFC NOT GENERATINGCFM}
  192.     INLINE $A9A3;
  193.     {$ENDC}
  194. PROCEDURE DetachResource(theResource: Handle);
  195.     {$IFC NOT GENERATINGCFM}
  196.     INLINE $A992;
  197.     {$ENDC}
  198. FUNCTION UniqueID(theType: ResType): INTEGER;
  199.     {$IFC NOT GENERATINGCFM}
  200.     INLINE $A9C1;
  201.     {$ENDC}
  202. FUNCTION Unique1ID(theType: ResType): INTEGER;
  203.     {$IFC NOT GENERATINGCFM}
  204.     INLINE $A810;
  205.     {$ENDC}
  206. FUNCTION GetResAttrs(theResource: Handle): INTEGER;
  207.     {$IFC NOT GENERATINGCFM}
  208.     INLINE $A9A6;
  209.     {$ENDC}
  210. PROCEDURE GetResInfo(theResource: Handle; VAR theID: INTEGER; VAR theType: ResType; VAR name: Str255);
  211.     {$IFC NOT GENERATINGCFM}
  212.     INLINE $A9A8;
  213.     {$ENDC}
  214. PROCEDURE SetResInfo(theResource: Handle; theID: INTEGER; name: ConstStr255Param);
  215.     {$IFC NOT GENERATINGCFM}
  216.     INLINE $A9A9;
  217.     {$ENDC}
  218. PROCEDURE AddResource(theData: Handle; theType: ResType; theID: INTEGER; name: ConstStr255Param);
  219.     {$IFC NOT GENERATINGCFM}
  220.     INLINE $A9AB;
  221.     {$ENDC}
  222. FUNCTION GetResourceSizeOnDisk(theResource: Handle): LONGINT;
  223.     {$IFC NOT GENERATINGCFM}
  224.     INLINE $A9A5;
  225.     {$ENDC}
  226. FUNCTION GetMaxResourceSize(theResource: Handle): LONGINT;
  227.     {$IFC NOT GENERATINGCFM}
  228.     INLINE $A821;
  229.     {$ENDC}
  230. FUNCTION RsrcMapEntry(theResource: Handle): LONGINT;
  231.     {$IFC NOT GENERATINGCFM}
  232.     INLINE $A9C5;
  233.     {$ENDC}
  234. PROCEDURE SetResAttrs(theResource: Handle; attrs: INTEGER);
  235.     {$IFC NOT GENERATINGCFM}
  236.     INLINE $A9A7;
  237.     {$ENDC}
  238. PROCEDURE ChangedResource(theResource: Handle);
  239.     {$IFC NOT GENERATINGCFM}
  240.     INLINE $A9AA;
  241.     {$ENDC}
  242. PROCEDURE RemoveResource(theResource: Handle);
  243.     {$IFC NOT GENERATINGCFM}
  244.     INLINE $A9AD;
  245.     {$ENDC}
  246. PROCEDURE UpdateResFile(refNum: INTEGER);
  247.     {$IFC NOT GENERATINGCFM}
  248.     INLINE $A999;
  249.     {$ENDC}
  250. PROCEDURE WriteResource(theResource: Handle);
  251.     {$IFC NOT GENERATINGCFM}
  252.     INLINE $A9B0;
  253.     {$ENDC}
  254. PROCEDURE SetResPurge(install: BOOLEAN);
  255.     {$IFC NOT GENERATINGCFM}
  256.     INLINE $A993;
  257.     {$ENDC}
  258. FUNCTION GetResFileAttrs(refNum: INTEGER): INTEGER;
  259.     {$IFC NOT GENERATINGCFM}
  260.     INLINE $A9F6;
  261.     {$ENDC}
  262. PROCEDURE SetResFileAttrs(refNum: INTEGER; attrs: INTEGER);
  263.     {$IFC NOT GENERATINGCFM}
  264.     INLINE $A9F7;
  265.     {$ENDC}
  266. FUNCTION OpenRFPerm(fileName: ConstStr255Param; vRefNum: INTEGER; permission: ByteParameter): INTEGER;
  267.     {$IFC NOT GENERATINGCFM}
  268.     INLINE $A9C4;
  269.     {$ENDC}
  270. FUNCTION RGetResource(theType: ResType; theID: INTEGER): Handle;
  271.     {$IFC NOT GENERATINGCFM}
  272.     INLINE $A80C;
  273.     {$ENDC}
  274. {$IFC SystemSevenOrLater }
  275. FUNCTION HOpenResFile(vRefNum: INTEGER; dirID: LONGINT; fileName: ConstStr255Param; permission: ByteParameter): INTEGER;
  276.     {$IFC NOT GENERATINGCFM}
  277.     INLINE $A81A;
  278.     {$ENDC}
  279. {$ELSEC}
  280. FUNCTION HOpenResFile(vRefNum: INTEGER; dirID: LONGINT; fileName: ConstStr255Param; permission: ByteParameter): INTEGER;
  281. {$ENDC}
  282. {$IFC SystemSevenOrLater }
  283. PROCEDURE HCreateResFile(vRefNum: INTEGER; dirID: LONGINT; fileName: ConstStr255Param);
  284.     {$IFC NOT GENERATINGCFM}
  285.     INLINE $A81B;
  286.     {$ENDC}
  287. {$ELSEC}
  288. PROCEDURE HCreateResFile(vRefNum: INTEGER; dirID: LONGINT; fileName: ConstStr255Param);
  289. {$ENDC}
  290. FUNCTION FSpOpenResFile({CONST}VAR spec: FSSpec; permission: ByteParameter): INTEGER;
  291.     {$IFC NOT GENERATINGCFM}
  292.     INLINE $700D, $AA52;
  293.     {$ENDC}
  294. PROCEDURE FSpCreateResFile({CONST}VAR spec: FSSpec; creator: OSType; fileType: OSType; scriptTag: ScriptCode);
  295.     {$IFC NOT GENERATINGCFM}
  296.     INLINE $700E, $AA52;
  297.     {$ENDC}
  298. {  partial resource calls  }
  299. PROCEDURE ReadPartialResource(theResource: Handle; offset: LONGINT; buffer: UNIV Ptr; count: LONGINT);
  300.     {$IFC NOT GENERATINGCFM}
  301.     INLINE $7001, $A822;
  302.     {$ENDC}
  303. PROCEDURE WritePartialResource(theResource: Handle; offset: LONGINT; buffer: UNIV Ptr; count: LONGINT);
  304.     {$IFC NOT GENERATINGCFM}
  305.     INLINE $7002, $A822;
  306.     {$ENDC}
  307. PROCEDURE SetResourceSize(theResource: Handle; newSize: LONGINT);
  308.     {$IFC NOT GENERATINGCFM}
  309.     INLINE $7003, $A822;
  310.     {$ENDC}
  311. FUNCTION GetNextFOND(fondHandle: Handle): Handle;
  312.     {$IFC NOT GENERATINGCFM}
  313.     INLINE $700A, $A822;
  314.     {$ENDC}
  315. { Use TempInsertROMMap to force the ROM resource map to be
  316.    inserted into the chain in front of the system. Note that
  317.    this call is only temporary - the modified resource chain
  318.    is only used for the next call to the resource manager.
  319.    See IM IV 19 for more information. }
  320. PROCEDURE TempInsertROMMap(tempResLoad: BOOLEAN);
  321. {$IFC OLDROUTINENAMES }
  322. FUNCTION SizeResource(theResource: Handle): LONGINT;
  323.     {$IFC NOT GENERATINGCFM}
  324.     INLINE $A9A5;
  325.     {$ENDC}
  326. FUNCTION MaxSizeRsrc(theResource: Handle): LONGINT;
  327.     {$IFC NOT GENERATINGCFM}
  328.     INLINE $A821;
  329.     {$ENDC}
  330. PROCEDURE RmveResource(theResource: Handle);
  331.     {$IFC NOT GENERATINGCFM}
  332.     INLINE $A9AD;
  333.     {$ENDC}
  334. {$ENDC}
  335.  
  336. {$ALIGN RESET}
  337. {$POP}
  338.  
  339. {$SETC UsingIncludes := ResourcesIncludes}
  340.  
  341. {$ENDC} {__RESOURCES__}
  342.  
  343. {$IFC NOT UsingIncludes}
  344.  END.
  345. {$ENDC}
  346.